import java.io.InputStream;
import java.io.IOException;

enum EstadoLexico {

    INICIO, RECPAP, RECPCIERRE, RECPYCOMA, RECSEP, RECIGUAL, RECSUMA,RECMUL,
    RECNUM, RECID, RECCOM, RECEOF
};

public class AnalizadorLexicoTiny {

    private final static int EOF = -1;
    private int caract;
    private EstadoLexico estado;
    private InputStream input;
    private String lexema;
    private int fila;
    private int col;
    private int filaInicio;
    private int colInicio;

    public AnalizadorLexicoTiny(InputStream input) throws IOException {
        this.input = input;
        fila = 0;
        col = -1;
        caract = sigCar();
    }

    public Token sigToken() throws IOException {
        estado = EstadoLexico.INICIO;
        filaInicio = fila;
        colInicio = col;
        lexema = "";
        while (true) {
            switch (estado) {
                case INICIO:
                    if (esLetra(caract)) {
                        transita(EstadoLexico.RECID);
                    } else if (esDigito(caract)) {
                        transita(EstadoLexico.RECNUM);
                    } else if (caract == '(') {
                        transita(EstadoLexico.RECPAP);
                    } else if (caract == ')') {
                        transita(EstadoLexico.RECPCIERRE);
                    } else if (caract == '+') {
                        transita(EstadoLexico.RECSUMA);
                    } else if (caract == '*') {
                        transita(EstadoLexico.RECMUL);
                    } else if (caract == '=') {
                        transita(EstadoLexico.RECIGUAL);
                    } else if (caract == '&') {
                        transita(EstadoLexico.RECSEP);
                    } else if (caract == ';') {
                        transita(EstadoLexico.RECPYCOMA);
                    } else if (caract == EOF) {
                        transita(EstadoLexico.RECEOF);
                    } else if (caract == '#') {
                        transita(EstadoLexico.RECCOM);
                    } else if (esSep(caract)) {
                        transitaIgnorando(EstadoLexico.INICIO);
                    } else {
                        errorLexico();
                    }
                    break;
                case RECPAP:
                    return new Token(filaInicio,colInicio,CatLexica.PAP);
                case RECPCIERRE:
                    return new Token(filaInicio,colInicio,CatLexica.PCIERRE);
                case RECPYCOMA:
                    return new Token(filaInicio,colInicio,CatLexica.PYCOMA);
                case RECSUMA:
                    return new Token(filaInicio,colInicio,CatLexica.SUMA);
                case RECMUL:
                    return new Token(filaInicio,colInicio,CatLexica.MUL);
                case RECIGUAL:
                    return new Token(filaInicio,colInicio,CatLexica.IGUAL);
                case RECSEP:
                    return new Token(filaInicio,colInicio,CatLexica.SEP);
                case RECNUM:
                    if (esDigito(caract)) {
                        transita(EstadoLexico.RECNUM);
                    } else {
                        return new Token(filaInicio,colInicio,CatLexica.NUM, lexema);
                    }
                    break;
                case RECID:
                    if (esLetra(caract) || esDigito(caract)) {
                        transita(EstadoLexico.RECID);
                    } else {
                        return new Token(filaInicio,colInicio,CatLexica.ID, lexema);
                    }
                    break;
                case RECEOF:
                    return new Token(filaInicio,colInicio,CatLexica.EOF);
                case RECCOM:
                    if (caract != '\n' && caract != EOF) {
                        transitaIgnorando(EstadoLexico.RECCOM);
                    } else {
                        transitaIgnorando(EstadoLexico.INICIO);
                    }
                    break;
            }
        }
    }

    private void transita(EstadoLexico aEstado) throws IOException {
        lexema = lexema + (char) caract;
        transitaIgnorando(aEstado);
    }

    private void transitaIgnorando(EstadoLexico aEstado) throws IOException {
        estado = aEstado;
        filaInicio = fila;
        colInicio = col;
        caract = sigCar();
    }

    private int sigCar() throws IOException {
        caract = input.read();
        if (caract == '\n') {
            col = -1;
            fila++;
        } else {
            col++;
        }
        return caract;
    }

    private boolean esLetra(int car) {
        return (car >= 'a' && car <= 'z') || (car >= 'A' && car <= 'Z');
    }

    private boolean esDigito(int car) {
        return (car >= '0' && car <= '9');
    }

    private boolean esSep(int car) {
        return car == ' ' || car == '\t' || car == '\n' || car == '\r' || car == '\b';
    }

    private void errorLexico() {
        System.err.println("(" + fila + "," + col + ")" + 
                "ERROR LEXICO: caracter desconocido:" + (char) caract);
        System.exit(1);
    }
    public static void main(String[] args) throws IOException {
      AnalizadorLexicoTiny alex = new AnalizadorLexicoTiny(System.in);
      Token t;
      do {
        t = alex.sigToken();
        System.out.println(t);       
      }
      while(t.leeCategoria() != CatLexica.EOF);
    }
    
}
